{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:36.267855Z",
     "start_time": "2025-03-01T01:58:23.506017Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "\n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n",
    "\n",
    "seed = 42\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 2.0.2\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.1\n",
      "torch 2.6.0+cu126\n",
      "cuda:0\n"
     ]
    }
   ],
   "execution_count": 1
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 准备数据"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:47.065309Z",
     "start_time": "2025-03-01T01:58:36.268856Z"
    }
   },
   "source": [
    "from tensorflow import keras  #这里的波浪线不用管\n",
    "\n",
    "#用karas有的数据集imdb，电影分类,分电影是积极的，还是消极的\n",
    "imdb = keras.datasets.imdb\n",
    "#载入数据使用下面两个参数\n",
    "vocab_size = 10000  #词典大小，仅保留训练数据中前10000个最经常出现的单词，低频单词被舍弃\n",
    "index_from = 3  #0,1,2,3空出来做别的事\n",
    "#前一万个词出现词频最高的会保留下来进行处理，后面的作为特殊字符处理，\n",
    "# 小于3的id都是特殊字符，下面代码有写\n",
    "# 需要注意的一点是取出来的词表还是从1开始的，需要做处理\n",
    "(train_data, train_labels), (test_data, test_labels) = imdb.load_data(\n",
    "    num_words=vocab_size, index_from=index_from)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/imdb.npz\n",
      "\u001B[1m17464789/17464789\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m3s\u001B[0m 0us/step\n"
     ]
    }
   ],
   "execution_count": 2
  },
  {
   "cell_type": "code",
   "source": [
    "type(train_labels)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:47.070441Z",
     "start_time": "2025-03-01T01:58:47.066310Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 3
  },
  {
   "cell_type": "code",
   "source": [
    "print(type(train_data))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:47.088662Z",
     "start_time": "2025-03-01T01:58:47.070441Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:47.093284Z",
     "start_time": "2025-03-01T01:58:47.089664Z"
    }
   },
   "cell_type": "code",
   "source": "train_data.shape  #每个样本是一段话，每个单词用一个数字表示",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(25000,)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 5
  },
  {
   "cell_type": "code",
   "source": [
    "type(train_data[0])"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:47.096854Z",
     "start_time": "2025-03-01T01:58:47.093284Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 6
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:47.100949Z",
     "start_time": "2025-03-01T01:58:47.096854Z"
    }
   },
   "cell_type": "code",
   "source": "train_data[2]",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " 14,\n",
       " 47,\n",
       " 8,\n",
       " 30,\n",
       " 31,\n",
       " 7,\n",
       " 4,\n",
       " 249,\n",
       " 108,\n",
       " 7,\n",
       " 4,\n",
       " 5974,\n",
       " 54,\n",
       " 61,\n",
       " 369,\n",
       " 13,\n",
       " 71,\n",
       " 149,\n",
       " 14,\n",
       " 22,\n",
       " 112,\n",
       " 4,\n",
       " 2401,\n",
       " 311,\n",
       " 12,\n",
       " 16,\n",
       " 3711,\n",
       " 33,\n",
       " 75,\n",
       " 43,\n",
       " 1829,\n",
       " 296,\n",
       " 4,\n",
       " 86,\n",
       " 320,\n",
       " 35,\n",
       " 534,\n",
       " 19,\n",
       " 263,\n",
       " 4821,\n",
       " 1301,\n",
       " 4,\n",
       " 1873,\n",
       " 33,\n",
       " 89,\n",
       " 78,\n",
       " 12,\n",
       " 66,\n",
       " 16,\n",
       " 4,\n",
       " 360,\n",
       " 7,\n",
       " 4,\n",
       " 58,\n",
       " 316,\n",
       " 334,\n",
       " 11,\n",
       " 4,\n",
       " 1716,\n",
       " 43,\n",
       " 645,\n",
       " 662,\n",
       " 8,\n",
       " 257,\n",
       " 85,\n",
       " 1200,\n",
       " 42,\n",
       " 1228,\n",
       " 2578,\n",
       " 83,\n",
       " 68,\n",
       " 3912,\n",
       " 15,\n",
       " 36,\n",
       " 165,\n",
       " 1539,\n",
       " 278,\n",
       " 36,\n",
       " 69,\n",
       " 2,\n",
       " 780,\n",
       " 8,\n",
       " 106,\n",
       " 14,\n",
       " 6905,\n",
       " 1338,\n",
       " 18,\n",
       " 6,\n",
       " 22,\n",
       " 12,\n",
       " 215,\n",
       " 28,\n",
       " 610,\n",
       " 40,\n",
       " 6,\n",
       " 87,\n",
       " 326,\n",
       " 23,\n",
       " 2300,\n",
       " 21,\n",
       " 23,\n",
       " 22,\n",
       " 12,\n",
       " 272,\n",
       " 40,\n",
       " 57,\n",
       " 31,\n",
       " 11,\n",
       " 4,\n",
       " 22,\n",
       " 47,\n",
       " 6,\n",
       " 2307,\n",
       " 51,\n",
       " 9,\n",
       " 170,\n",
       " 23,\n",
       " 595,\n",
       " 116,\n",
       " 595,\n",
       " 1352,\n",
       " 13,\n",
       " 191,\n",
       " 79,\n",
       " 638,\n",
       " 89,\n",
       " 2,\n",
       " 14,\n",
       " 9,\n",
       " 8,\n",
       " 106,\n",
       " 607,\n",
       " 624,\n",
       " 35,\n",
       " 534,\n",
       " 6,\n",
       " 227,\n",
       " 7,\n",
       " 129,\n",
       " 113]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 7
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:47.104541Z",
     "start_time": "2025-03-01T01:58:47.100949Z"
    }
   },
   "cell_type": "code",
   "source": "len(train_data[0])",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "218"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 8
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:47.108038Z",
     "start_time": "2025-03-01T01:58:47.104541Z"
    }
   },
   "cell_type": "code",
   "source": "len(train_data[1])",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "189"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 9
  },
  {
   "cell_type": "code",
   "source": [
    "train_labels[0:10]  #二分类"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:47.112455Z",
     "start_time": "2025-03-01T01:58:47.108038Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0, 0, 1, 0, 0, 1, 0, 1, 0])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 10
  },
  {
   "cell_type": "code",
   "source": [
    "print(\"train\", len(train_data), train_labels.shape)  #25000个样本，每个样本是一段话，每个单词用一个数字表示\n",
    "print(\"test\", len(test_data), test_labels.shape)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:47.115925Z",
     "start_time": "2025-03-01T01:58:47.112455Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train 25000 (25000,)\n",
      "test 25000 (25000,)\n"
     ]
    }
   ],
   "execution_count": 11
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:49.415281Z",
     "start_time": "2025-03-01T01:58:47.115925Z"
    }
   },
   "source": [
    "#载入词表，看下词表长度，词表就像英语字典\n",
    "word_index = imdb.get_word_index()\n",
    "print(len(word_index))\n",
    "print(type(word_index))\n",
    "#词表虽然有8万多，但是我们只载入了最高频的1万词！！！！"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/imdb_word_index.json\n",
      "\u001B[1m1641221/1641221\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m2s\u001B[0m 1us/step\n",
      "88584\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "execution_count": 12
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 构造 word2idx 和 idx2word"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:49.449708Z",
     "start_time": "2025-03-01T01:58:49.416282Z"
    }
   },
   "source": [
    "word2idx = {word: idx + 3 for word, idx in word_index.items()}  # 0,1,2,3空出来做别的事,这里的idx是从1开始的,所以加3\n",
    "word2idx.update({\n",
    "    \"[PAD]\": 0,  # 填充 token\n",
    "    \"[BOS]\": 1,  # begin of sentence\n",
    "    \"[UNK]\": 2,  # 未知 token\n",
    "    \"[EOS]\": 3,  # end of sentence\n",
    "})\n",
    "\n",
    "idx2word = {idx: word for word, idx in word2idx.items()}  # 反向词典,id变为单词"
   ],
   "outputs": [],
   "execution_count": 13
  },
  {
   "cell_type": "code",
   "source": "print(word2idx[\"world\"])",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:49.461999Z",
     "start_time": "2025-03-01T01:58:49.451705Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "182\n"
     ]
    }
   ],
   "execution_count": 14
  },
  {
   "cell_type": "code",
   "source": "idx2word[4]",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:49.465702Z",
     "start_time": "2025-03-01T01:58:49.461999Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'the'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 15
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:50.420870Z",
     "start_time": "2025-03-01T01:58:49.465702Z"
    }
   },
   "source": [
    "# 选择 max_length\n",
    "length_collect = {}\n",
    "#统计样本中每个长度出现的次数\n",
    "for text in train_data:\n",
    "    length = len(text)  #句子长度\n",
    "    length_collect[length] = length_collect.get(length, 0) + 1  #统计长度的频率\n",
    "\n",
    "MAX_LENGTH = 500\n",
    "plt.bar(length_collect.keys(), length_collect.values())  #长度分布图\n",
    "plt.axvline(MAX_LENGTH, label=\"max length\", c=\"gray\", ls=\":\")  #画一条线，可以看到大部分都在500以内\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 16
  },
  {
   "cell_type": "code",
   "source": [
    "#想对句子长度画个直方图，看看长度分布\n",
    "length_list = [len(text) for text in train_data]\n",
    "plt.hist(length_list, bins=50)\n",
    "plt.xlabel(\"length\")\n",
    "plt.ylabel(\"frequency\")\n",
    "plt.axvline(500, label=\"max length\", c=\"gray\", ls=\":\")\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:50.568906Z",
     "start_time": "2025-03-01T01:58:50.421871Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 17
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "length_list[0:10]"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:50.572864Z",
     "start_time": "2025-03-01T01:58:50.568906Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[218, 189, 141, 550, 147, 43, 123, 562, 233, 130]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 18
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:50.576747Z",
     "start_time": "2025-03-01T01:58:50.572864Z"
    }
   },
   "cell_type": "code",
   "source": [
    "raw_text = [\"hello world\".split(), \"tokenize text datas with batch\".split(), \"this is a test\".split()]\n",
    "raw_text"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['hello', 'world'],\n",
       " ['tokenize', 'text', 'datas', 'with', 'batch'],\n",
       " ['this', 'is', 'a', 'test']]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 19
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tokenizer"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:50.604923Z",
     "start_time": "2025-03-01T01:58:50.576747Z"
    }
   },
   "source": [
    "class Tokenizer:\n",
    "    def __init__(self, word2idx, idx2word, max_length=500, pad_idx=0, bos_idx=1, eos_idx=3, unk_idx=2):\n",
    "        self.word2idx = word2idx  #词表,单词到id\n",
    "        self.idx2word = idx2word  #词表，id到单词\n",
    "        self.max_length = max_length\n",
    "        self.pad_idx = pad_idx  #填充\n",
    "        self.bos_idx = bos_idx  #开始\n",
    "        self.eos_idx = eos_idx  #结束\n",
    "        self.unk_idx = unk_idx  #未知，未出现在最高频词表中的词\n",
    "\n",
    "    def encode(self, text_list):\n",
    "        \"\"\"\n",
    "        将文本列表转化为索引列表\n",
    "        :param text_list:当前批次的文本列表\n",
    "        :return:\n",
    "        \"\"\"\n",
    "        max_length = min(self.max_length, 2 + max(\n",
    "            [len(text) for text in text_list]))  #最大长度，最大长度是500，但是如果句子长度小于500，就取句子长度（句子长度是本组句子中最长的），2是为了留出开始和结束的位置\n",
    "        indices = []\n",
    "        for text in text_list:\n",
    "            index = [self.word2idx.get(word, self.unk_idx) for word in text]  #单词转化为id，未知的词用unk_idx代替\n",
    "            index = [self.bos_idx] + index + [self.eos_idx]  #添加开始和结束\n",
    "            if len(index) < max_length:\n",
    "                index = index + [self.pad_idx] * (max_length - len(index))  #填充0\n",
    "            else:\n",
    "                index = index[:max_length]  #如果句子长度大于500，就截断\n",
    "            indices.append(index)\n",
    "        return torch.tensor(indices)  #二维列表转化为tensor\n",
    "\n",
    "    def decode(self, indices_list, remove_bos=True, remove_eos=True, remove_pad=True, split=False):\n",
    "        \"\"\"\n",
    "        将索引列表转化为文本列表\n",
    "        :param indices_list:某批次的索引列表\n",
    "        :param remove_bos:\n",
    "        :param remove_eos:\n",
    "        :param remove_pad:\n",
    "        :param split:\n",
    "        :return:\n",
    "        \"\"\"\n",
    "        text_list = []\n",
    "        for indices in indices_list:\n",
    "            text = []\n",
    "            for index in indices:\n",
    "                word = self.idx2word.get(index, \"[UNK]\")\n",
    "                if remove_bos and word == \"[BOS]\":\n",
    "                    continue\n",
    "                if remove_eos and word == \"[EOS]\":\n",
    "                    break\n",
    "                if remove_pad and word == \"[PAD]\":\n",
    "                    break\n",
    "                text.append(word)\n",
    "            text_list.append(\" \".join(text) if not split else text)\n",
    "        return text_list\n",
    "\n",
    "\n",
    "tokenizer = Tokenizer(word2idx=word2idx, idx2word=idx2word)\n",
    "raw_text = [\"hello world\".split(), \"tokenize text datas with batch\".split(), \"this is a test\".split()]\n",
    "indices = tokenizer.encode(raw_text)  #encode支持批量处理\n",
    "print(\"raw text\")\n",
    "for raw in raw_text:\n",
    "    print(raw)\n",
    "print(\"indices\")\n",
    "for index in indices:\n",
    "    print(index)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "raw text\n",
      "['hello', 'world']\n",
      "['tokenize', 'text', 'datas', 'with', 'batch']\n",
      "['this', 'is', 'a', 'test']\n",
      "indices\n",
      "tensor([   1, 4825,  182,    3,    0,    0,    0])\n",
      "tensor([    1,     2,  3004,     2,    19, 19233,     3])\n",
      "tensor([   1,   14,    9,    6, 2181,    3,    0])\n"
     ]
    }
   ],
   "execution_count": 20
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:50.608371Z",
     "start_time": "2025-03-01T01:58:50.604923Z"
    }
   },
   "cell_type": "code",
   "source": [
    "decode_text = tokenizer.decode(indices.tolist(), remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "print(\"decode text----------\")\n",
    "for decode in decode_text:\n",
    "    print(decode)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "decode text----------\n",
      "[BOS] hello world [EOS] [PAD] [PAD] [PAD]\n",
      "[BOS] [UNK] text [UNK] with batch [EOS]\n",
      "[BOS] this is a test [EOS] [PAD]\n"
     ]
    }
   ],
   "execution_count": 21
  },
  {
   "cell_type": "code",
   "source": [
    "train_data[0:1]"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:50.612564Z",
     "start_time": "2025-03-01T01:58:50.608371Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([list([1, 14, 22, 16, 43, 530, 973, 1622, 1385, 65, 458, 4468, 66, 3941, 4, 173, 36, 256, 5, 25, 100, 43, 838, 112, 50, 670, 2, 9, 35, 480, 284, 5, 150, 4, 172, 112, 167, 2, 336, 385, 39, 4, 172, 4536, 1111, 17, 546, 38, 13, 447, 4, 192, 50, 16, 6, 147, 2025, 19, 14, 22, 4, 1920, 4613, 469, 4, 22, 71, 87, 12, 16, 43, 530, 38, 76, 15, 13, 1247, 4, 22, 17, 515, 17, 12, 16, 626, 18, 2, 5, 62, 386, 12, 8, 316, 8, 106, 5, 4, 2223, 5244, 16, 480, 66, 3785, 33, 4, 130, 12, 16, 38, 619, 5, 25, 124, 51, 36, 135, 48, 25, 1415, 33, 6, 22, 12, 215, 28, 77, 52, 5, 14, 407, 16, 82, 2, 8, 4, 107, 117, 5952, 15, 256, 4, 2, 7, 3766, 5, 723, 36, 71, 43, 530, 476, 26, 400, 317, 46, 7, 4, 2, 1029, 13, 104, 88, 4, 381, 15, 297, 98, 32, 2071, 56, 26, 141, 6, 194, 7486, 18, 4, 226, 22, 21, 134, 476, 26, 480, 5, 144, 30, 5535, 18, 51, 36, 28, 224, 92, 25, 104, 4, 226, 65, 16, 38, 1334, 88, 12, 16, 283, 5, 16, 4472, 113, 103, 32, 15, 16, 5345, 19, 178, 32])],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 22
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:50.616300Z",
     "start_time": "2025-03-01T01:58:50.612564Z"
    }
   },
   "source": [
    "# 看看训练集的数据\n",
    "tokenizer.decode(train_data[0:1], remove_bos=False, remove_eos=False, remove_pad=False)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"[BOS] this film was just brilliant casting location scenery story direction everyone's really suited the part they played and you could just imagine being there robert [UNK] is an amazing actor and now the same being director [UNK] father came from the same scottish island as myself so i loved the fact there was a real connection with this film the witty remarks throughout the film were great it was just brilliant so much that i bought the film as soon as it was released for [UNK] and would recommend it to everyone to watch and the fly fishing was amazing really cried at the end it was so sad and you know what they say if you cry at a film it must have been good and this definitely was also [UNK] to the two little boy's that played the [UNK] of norman and paul they were just brilliant children are often left out of the [UNK] list i think because the stars that play them all grown up are such a big profile for the whole film but these children are amazing and should be praised for what they have done don't you think the whole story was so lovely because it was true and was someone's life after all that was shared with us all\"]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 23
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据集与 DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:51.621935Z",
     "start_time": "2025-03-01T01:58:50.616300Z"
    }
   },
   "source": [
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "\n",
    "class IMDBDataset(Dataset):\n",
    "    def __init__(self, data, labels, remain_length=True):\n",
    "        if remain_length:  #字符串输出样本中，是否含有【BOS】和【EOS】，【PAD】\n",
    "            self.data = tokenizer.decode(data, remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "        else:\n",
    "            # 缩减一下数据\n",
    "            self.data = tokenizer.decode(data)\n",
    "        self.labels = labels\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        text = self.data[index]\n",
    "        label = self.labels[index]\n",
    "        return text, label\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "\n",
    "\n",
    "def collate_fct(batch):\n",
    "    \"\"\"\n",
    "    将batch数据处理成tensor形式\n",
    "    :param batch:\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    text_list = [item[0].split() for item in batch]  #batch是128样本，每个样本类型是元组，第一个元素是文本，第二个元素是标签\n",
    "    label_list = [item[1] for item in batch]\n",
    "    text_list = tokenizer.encode(text_list).to(dtype=torch.int)  # 文本转化为索引\n",
    "    return text_list, torch.tensor(label_list).reshape(-1, 1).to(dtype=torch.float)\n",
    "\n",
    "\n",
    "train_ds = IMDBDataset(train_data, train_labels)\n",
    "test_ds = IMDBDataset(test_data, test_labels)"
   ],
   "outputs": [],
   "execution_count": 24
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:51.626306Z",
     "start_time": "2025-03-01T01:58:51.621935Z"
    }
   },
   "source": [
    "batch_size = 128\n",
    "train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True, collate_fn=collate_fct)  #collate_fn是处理batch的函数\n",
    "test_dl = DataLoader(test_ds, batch_size=batch_size, shuffle=False, collate_fn=collate_fct)"
   ],
   "outputs": [],
   "execution_count": 25
  },
  {
   "cell_type": "code",
   "source": [
    "#要看到每个batch的长度不同，需要修改batch_size为12\n",
    "i=0\n",
    "for text, label in train_dl:\n",
    "    print(text.shape, label.shape)\n",
    "    i+=1\n",
    "    if i==50:\n",
    "        break"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:52.247688Z",
     "start_time": "2025-03-01T01:58:51.626306Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n"
     ]
    }
   ],
   "execution_count": 26
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 定义模型"
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:52.252685Z",
     "start_time": "2025-03-01T01:58:52.248684Z"
    }
   },
   "cell_type": "code",
   "source": "(128,500,10000)",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(128, 500, 10000)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 27
  },
  {
   "cell_type": "code",
   "source": [
    "# target output size of 5\n",
    "m = nn.AdaptiveAvgPool1d(1)  # 自适应平均池化\n",
    "input = torch.randn(1, 3, 9)\n",
    "output = m(input)\n",
    "output.size()  #可以看到最后一维变成了1"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:52.296353Z",
     "start_time": "2025-03-01T01:58:52.252685Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 3, 1])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 28
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:52.305643Z",
     "start_time": "2025-03-01T01:58:52.297356Z"
    }
   },
   "source": [
    "class AddingModel(nn.Module):\n",
    "    def __init__(self, embedding_dim=16, hidden_dim=64, vocab_size=vocab_size):\n",
    "        super(AddingModel, self).__init__()\n",
    "        self.embeding = nn.Embedding(vocab_size, embedding_dim)  # 词嵌入\n",
    "        self.pool = nn.AdaptiveAvgPool1d(1)  # 自适应平均池化,对应tf是全局平均值池化\n",
    "        self.layer = nn.Linear(embedding_dim, hidden_dim)  # 全连接层\n",
    "        self.fc = nn.Linear(hidden_dim, 1)  # 全连接层\n",
    "\n",
    "    def forward(self, x):\n",
    "        # [bs, seq length] [128, 500]  [128,500,10000]--->[128,500,16]\n",
    "        x = self.embeding(x)\n",
    "        # [bs, seq length, embedding_dim]-->[bs, embedding_dim, seq length]，尺寸[128,500,16]--》[128,16,500]\n",
    "        x = x.permute(0, 2, 1)\n",
    "        x = self.pool(x)  # 每个样本变为一个密集向量，在seq_length维度上进行平均池化，[128,16,500]-->[128,16,1]\n",
    "        x=x.squeeze(2)  # [bs, embedding_dim, 1] ->[bs, embedding_dim]\n",
    "        # [bs, embedding_dim] -> [bs, hidden_dim]\n",
    "        x = self.layer(x)\n",
    "        x = self.fc(x)  # [bs, hidden_dim] -> [bs, 1]\n",
    "\n",
    "        return x\n",
    "\n",
    "\n",
    "for key, value in AddingModel().named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            embeding.weight             paramerters num: 160000\n",
      "              layer.weight              paramerters num: 1024\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n"
     ]
    }
   ],
   "execution_count": 29
  },
  {
   "cell_type": "code",
   "source": [
    "16 * 64"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:52.309975Z",
     "start_time": "2025-03-01T01:58:52.306645Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1024"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 30
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 训练"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:52.665183Z",
     "start_time": "2025-03-01T01:58:52.310977Z"
    }
   },
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)  # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        # 二分类\n",
    "        preds = logits > 0\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "\n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ],
   "outputs": [],
   "execution_count": 31
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TensorBoard 可视化\n",
    "\n",
    "\n",
    "训练过程中可以使用如下命令启动tensorboard服务。\n",
    "\n",
    "```shell\n",
    "tensorboard \\\n",
    "    --logdir=runs \\     # log 存放路径\n",
    "    --host 0.0.0.0 \\    # ip\n",
    "    --port 8848         # 端口\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:52.820235Z",
     "start_time": "2025-03-01T01:58:52.665183Z"
    }
   },
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "\n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\",\n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "        )\n",
    "\n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "\n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "\n",
    "        )\n",
    "\n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ],
   "outputs": [],
   "execution_count": 32
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save Best\n"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:52.824661Z",
     "start_time": "2025-03-01T01:58:52.821236Z"
    }
   },
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "\n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "\n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "\n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ],
   "outputs": [],
   "execution_count": 33
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Early Stop"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T01:58:52.828610Z",
     "start_time": "2025-03-01T01:58:52.824661Z"
    }
   },
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "\n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else:\n",
    "            self.counter += 1\n",
    "\n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ],
   "outputs": [],
   "execution_count": 34
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T02:00:29.302397Z",
     "start_time": "2025-03-01T01:58:52.828610Z"
    }
   },
   "source": [
    "# 训练\n",
    "def training(\n",
    "        model,\n",
    "        train_loader,\n",
    "        val_loader,\n",
    "        epoch,\n",
    "        loss_fct,\n",
    "        optimizer,\n",
    "        tensorboard_callback=None,\n",
    "        save_ckpt_callback=None,\n",
    "        early_stop_callback=None,\n",
    "        eval_step=500,\n",
    "):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "\n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits > 0 #当sigmoid输出大于0.5时，预测为1，否则预测为0，这里大于0，刚好sigmoid的值是0.5，预测为1\n",
    "\n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())\n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "\n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "\n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "\n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step,\n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                        )\n",
    "\n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "\n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "\n",
    "    return record_dict\n",
    "\n",
    "\n",
    "epoch = 20\n",
    "\n",
    "model = AddingModel()\n",
    "\n",
    "# 1. 定义损失函数 采用二进制交叉熵损失, 先sigmoid再计算交叉熵\n",
    "loss_fct = F.binary_cross_entropy_with_logits\n",
    "# loss_fct =nn.BCEWithLogitsLoss()\n",
    "# 2. 定义优化器 采用 adam\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "if not os.path.exists(\"runs\"):\n",
    "    os.mkdir(\"runs\")\n",
    "tensorboard_callback = TensorBoardCallback(\"runs/imdb-adding\")\n",
    "# tensorboard_callback.draw_model(model, [1, MAX_LENGTH])\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/imdb-adding\", save_step=len(train_dl), save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=5)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model,\n",
    "    train_dl,\n",
    "    test_dl,\n",
    "    epoch,\n",
    "    loss_fct,\n",
    "    optimizer,\n",
    "    tensorboard_callback=tensorboard_callback,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_dl)\n",
    ")"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/3920 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "8376dda9df42466bb2e40b8a07b58f55"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 13 / global_step 2548\n"
     ]
    }
   ],
   "execution_count": 35
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T02:00:29.491055Z",
     "start_time": "2025-03-01T02:00:29.303398Z"
    }
   },
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):\n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        # axs[idx].set_xticks(range(0, train_df.index[-1], 5000))\n",
    "        # axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", range(0, train_df.index[-1], 5000)))\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_learning_curves(record, sample_step=10)  #横坐标是 steps"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 36
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 评估"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-01T02:00:32.126099Z",
     "start_time": "2025-03-01T02:00:29.491055Z"
    }
   },
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/imdb-adding/best.ckpt\", weights_only=True,map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, test_dl, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.3180\n",
      "accuracy: 0.8754\n"
     ]
    }
   ],
   "execution_count": 37
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
